/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package controllers;

import concursos.concurso.NormaComplementar;
import controllers.exceptions.NonexistentEntityException;
import controllers.exceptions.PreexistingEntityException;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import concursos.concurso.Bibliografia;
import java.util.HashSet;
import java.util.Set;
import concursos.concurso.Ponto;
import concursos.concurso.Sorteio;

/**
 *
 * @author lucena
 */
public class NormaComplementarJpaController {

    public NormaComplementarJpaController() {
        emf = Persistence.createEntityManagerFactory("concursosPU");
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(NormaComplementar normaComplementar) throws PreexistingEntityException, Exception {
        if (normaComplementar.getBibliografia() == null) {
            normaComplementar.setBibliografia(new HashSet<Bibliografia>());
        }
        if (normaComplementar.getPonto() == null) {
            normaComplementar.setPonto(new HashSet<Ponto>());
        }
        if (normaComplementar.getSorteio() == null) {
            normaComplementar.setSorteio(new HashSet<Sorteio>());
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Set<Bibliografia> attachedBibliografia = new HashSet<Bibliografia>();
            for (Bibliografia bibliografiaBibliografiaToAttach : normaComplementar.getBibliografia()) {
                bibliografiaBibliografiaToAttach = em.getReference(bibliografiaBibliografiaToAttach.getClass(), bibliografiaBibliografiaToAttach.getId());
                attachedBibliografia.add(bibliografiaBibliografiaToAttach);
            }
            normaComplementar.setBibliografia(attachedBibliografia);
            Set<Ponto> attachedPonto = new HashSet<Ponto>();
            for (Ponto pontoPontoToAttach : normaComplementar.getPonto()) {
                pontoPontoToAttach = em.getReference(pontoPontoToAttach.getClass(), pontoPontoToAttach.getId());
                attachedPonto.add(pontoPontoToAttach);
            }
            normaComplementar.setPonto(attachedPonto);
            Set<Sorteio> attachedSorteio = new HashSet<Sorteio>();
            for (Sorteio sorteioSorteioToAttach : normaComplementar.getSorteio()) {
                sorteioSorteioToAttach = em.getReference(sorteioSorteioToAttach.getClass(), sorteioSorteioToAttach.getId());
                attachedSorteio.add(sorteioSorteioToAttach);
            }
            normaComplementar.setSorteio(attachedSorteio);
            em.persist(normaComplementar);
            for (Bibliografia bibliografiaBibliografia : normaComplementar.getBibliografia()) {
                NormaComplementar oldNormaComplementarOfBibliografiaBibliografia = bibliografiaBibliografia.getNormaComplementar();
                bibliografiaBibliografia.setNormaComplementar(normaComplementar);
                bibliografiaBibliografia = em.merge(bibliografiaBibliografia);
                if (oldNormaComplementarOfBibliografiaBibliografia != null) {
                    oldNormaComplementarOfBibliografiaBibliografia.getBibliografia().remove(bibliografiaBibliografia);
                    oldNormaComplementarOfBibliografiaBibliografia = em.merge(oldNormaComplementarOfBibliografiaBibliografia);
                }
            }
            for (Ponto pontoPonto : normaComplementar.getPonto()) {
                NormaComplementar oldNormaComplementarOfPontoPonto = pontoPonto.getNormaComplementar();
                pontoPonto.setNormaComplementar(normaComplementar);
                pontoPonto = em.merge(pontoPonto);
                if (oldNormaComplementarOfPontoPonto != null) {
                    oldNormaComplementarOfPontoPonto.getPonto().remove(pontoPonto);
                    oldNormaComplementarOfPontoPonto = em.merge(oldNormaComplementarOfPontoPonto);
                }
            }
            for (Sorteio sorteioSorteio : normaComplementar.getSorteio()) {
                NormaComplementar oldNormaComplementarOfSorteioSorteio = sorteioSorteio.getNormaComplementar();
                sorteioSorteio.setNormaComplementar(normaComplementar);
                sorteioSorteio = em.merge(sorteioSorteio);
                if (oldNormaComplementarOfSorteioSorteio != null) {
                    oldNormaComplementarOfSorteioSorteio.getSorteio().remove(sorteioSorteio);
                    oldNormaComplementarOfSorteioSorteio = em.merge(oldNormaComplementarOfSorteioSorteio);
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            if (findNormaComplementar(normaComplementar.getId()) != null) {
                throw new PreexistingEntityException("NormaComplementar " + normaComplementar + " already exists.", ex);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(NormaComplementar normaComplementar) throws NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            NormaComplementar persistentNormaComplementar = em.find(NormaComplementar.class, normaComplementar.getId());
            Set<Bibliografia> bibliografiaOld = persistentNormaComplementar.getBibliografia();
            Set<Bibliografia> bibliografiaNew = normaComplementar.getBibliografia();
            Set<Ponto> pontoOld = persistentNormaComplementar.getPonto();
            Set<Ponto> pontoNew = normaComplementar.getPonto();
            Set<Sorteio> sorteioOld = persistentNormaComplementar.getSorteio();
            Set<Sorteio> sorteioNew = normaComplementar.getSorteio();
            Set<Bibliografia> attachedBibliografiaNew = new HashSet<Bibliografia>();
            for (Bibliografia bibliografiaNewBibliografiaToAttach : bibliografiaNew) {
                bibliografiaNewBibliografiaToAttach = em.getReference(bibliografiaNewBibliografiaToAttach.getClass(), bibliografiaNewBibliografiaToAttach.getId());
                attachedBibliografiaNew.add(bibliografiaNewBibliografiaToAttach);
            }
            bibliografiaNew = attachedBibliografiaNew;
            normaComplementar.setBibliografia(bibliografiaNew);
            Set<Ponto> attachedPontoNew = new HashSet<Ponto>();
            for (Ponto pontoNewPontoToAttach : pontoNew) {
                pontoNewPontoToAttach = em.getReference(pontoNewPontoToAttach.getClass(), pontoNewPontoToAttach.getId());
                attachedPontoNew.add(pontoNewPontoToAttach);
            }
            pontoNew = attachedPontoNew;
            normaComplementar.setPonto(pontoNew);
            Set<Sorteio> attachedSorteioNew = new HashSet<Sorteio>();
            for (Sorteio sorteioNewSorteioToAttach : sorteioNew) {
                sorteioNewSorteioToAttach = em.getReference(sorteioNewSorteioToAttach.getClass(), sorteioNewSorteioToAttach.getId());
                attachedSorteioNew.add(sorteioNewSorteioToAttach);
            }
            sorteioNew = attachedSorteioNew;
            normaComplementar.setSorteio(sorteioNew);
            normaComplementar = em.merge(normaComplementar);
            for (Bibliografia bibliografiaOldBibliografia : bibliografiaOld) {
                if (!bibliografiaNew.contains(bibliografiaOldBibliografia)) {
                    bibliografiaOldBibliografia.setNormaComplementar(null);
                    bibliografiaOldBibliografia = em.merge(bibliografiaOldBibliografia);
                }
            }
            for (Bibliografia bibliografiaNewBibliografia : bibliografiaNew) {
                if (!bibliografiaOld.contains(bibliografiaNewBibliografia)) {
                    NormaComplementar oldNormaComplementarOfBibliografiaNewBibliografia = bibliografiaNewBibliografia.getNormaComplementar();
                    bibliografiaNewBibliografia.setNormaComplementar(normaComplementar);
                    bibliografiaNewBibliografia = em.merge(bibliografiaNewBibliografia);
                    if (oldNormaComplementarOfBibliografiaNewBibliografia != null && !oldNormaComplementarOfBibliografiaNewBibliografia.equals(normaComplementar)) {
                        oldNormaComplementarOfBibliografiaNewBibliografia.getBibliografia().remove(bibliografiaNewBibliografia);
                        oldNormaComplementarOfBibliografiaNewBibliografia = em.merge(oldNormaComplementarOfBibliografiaNewBibliografia);
                    }
                }
            }
            for (Ponto pontoOldPonto : pontoOld) {
                if (!pontoNew.contains(pontoOldPonto)) {
                    pontoOldPonto.setNormaComplementar(null);
                    pontoOldPonto = em.merge(pontoOldPonto);
                }
            }
            for (Ponto pontoNewPonto : pontoNew) {
                if (!pontoOld.contains(pontoNewPonto)) {
                    NormaComplementar oldNormaComplementarOfPontoNewPonto = pontoNewPonto.getNormaComplementar();
                    pontoNewPonto.setNormaComplementar(normaComplementar);
                    pontoNewPonto = em.merge(pontoNewPonto);
                    if (oldNormaComplementarOfPontoNewPonto != null && !oldNormaComplementarOfPontoNewPonto.equals(normaComplementar)) {
                        oldNormaComplementarOfPontoNewPonto.getPonto().remove(pontoNewPonto);
                        oldNormaComplementarOfPontoNewPonto = em.merge(oldNormaComplementarOfPontoNewPonto);
                    }
                }
            }
            for (Sorteio sorteioOldSorteio : sorteioOld) {
                if (!sorteioNew.contains(sorteioOldSorteio)) {
                    sorteioOldSorteio.setNormaComplementar(null);
                    sorteioOldSorteio = em.merge(sorteioOldSorteio);
                }
            }
            for (Sorteio sorteioNewSorteio : sorteioNew) {
                if (!sorteioOld.contains(sorteioNewSorteio)) {
                    NormaComplementar oldNormaComplementarOfSorteioNewSorteio = sorteioNewSorteio.getNormaComplementar();
                    sorteioNewSorteio.setNormaComplementar(normaComplementar);
                    sorteioNewSorteio = em.merge(sorteioNewSorteio);
                    if (oldNormaComplementarOfSorteioNewSorteio != null && !oldNormaComplementarOfSorteioNewSorteio.equals(normaComplementar)) {
                        oldNormaComplementarOfSorteioNewSorteio.getSorteio().remove(sorteioNewSorteio);
                        oldNormaComplementarOfSorteioNewSorteio = em.merge(oldNormaComplementarOfSorteioNewSorteio);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                long id = normaComplementar.getId();
                if (findNormaComplementar(id) == null) {
                    throw new NonexistentEntityException("The normaComplementar with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(long id) throws NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            NormaComplementar normaComplementar;
            try {
                normaComplementar = em.getReference(NormaComplementar.class, id);
                normaComplementar.getId();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The normaComplementar with id " + id + " no longer exists.", enfe);
            }
            Set<Bibliografia> bibliografia = normaComplementar.getBibliografia();
            for (Bibliografia bibliografiaBibliografia : bibliografia) {
                bibliografiaBibliografia.setNormaComplementar(null);
                bibliografiaBibliografia = em.merge(bibliografiaBibliografia);
            }
            Set<Ponto> ponto = normaComplementar.getPonto();
            for (Ponto pontoPonto : ponto) {
                pontoPonto.setNormaComplementar(null);
                pontoPonto = em.merge(pontoPonto);
            }
            Set<Sorteio> sorteio = normaComplementar.getSorteio();
            for (Sorteio sorteioSorteio : sorteio) {
                sorteioSorteio.setNormaComplementar(null);
                sorteioSorteio = em.merge(sorteioSorteio);
            }
            em.remove(normaComplementar);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<NormaComplementar> findNormaComplementarEntities() {
        return findNormaComplementarEntities(true, -1, -1);
    }

    public List<NormaComplementar> findNormaComplementarEntities(int maxResults, int firstResult) {
        return findNormaComplementarEntities(false, maxResults, firstResult);
    }

    private List<NormaComplementar> findNormaComplementarEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            Query q = em.createQuery("select object(o) from NormaComplementar as o");
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public NormaComplementar findNormaComplementar(long id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(NormaComplementar.class, id);
        } finally {
            em.close();
        }
    }

    public int getNormaComplementarCount() {
        EntityManager em = getEntityManager();
        try {
            return ((Long) em.createQuery("select count(o) from NormaComplementar as o").getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }

}
